import {_decorator, Component, Constructor, Node } from "cc";
import { ModuleManager } from "./ModuleManager";

const { ccclass, property } = _decorator;
@ccclass('ModuleBase')
export class ModuleBase extends Component{
    // 容器用于存储消息事件
    protected _events:Map<string,Function> = new Map();
    protected backParent:Node = null;
    protected onLoad(): void {
        ModuleManager.Instance.addModule(this);
       
        
    }
    // 只是把管理者的接口 放到自己身上来
    protected getModule<T extends ModuleBase>(type:Constructor<T>):T | null{
        return ModuleManager.Instance.getModule(type);
    }

    // 保存备份的父节点
    set BkParent(node:Node){
        this.backParent = node;
    }
    // 获取备份的父节点
    get BkParent(){
        return this.backParent;
    }

    // 模块注册消息的接口
    onMsg(msg:string,callback:Function){
        this._events.set(msg,callback);
    }

    // 模块激活消息的接口
    callEvent(msg,...args){
        const callback = this._events.get(msg);
        callback && callback.apply(this,[...args]);
    }


    // 把自己从场景中 拿走
    unUse(){
        if (this.backParent) {
            return;
        }
        // 保存一下当前的父节点
        this.backParent = this.node.parent;
        this.node.removeFromParent();
    }

    reUse(){
        if (!this.backParent) {
            return;
        }
        this.node.parent = this.backParent;
        // 备份父节点 置空
        this.backParent = null;
    }

    // 获取模块的接口 得到那些继承于ModuleBase的子类对象
    // extends 限制T的类型范围 必须是某类的子类类型
    // 如果用map容器 获取接口 ：
    // getModule<T extends ModuleBase>(name:string):T{
    //     return (this._modules.get(name)) as T;
    // }

    
    getModuleByName<T extends ModuleBase>(name:string):T | null{
        return ModuleManager.Instance.getModuleByName(name);
    }

    sendMsg(moduleName:string,msg:string,...args){
        ModuleManager.Instance.sendMsg(moduleName,msg,...args);
    }
}